# string_functions.py

def reverse_string(s):
    return s[::-1]

def uppercase_string(s):
    return s.upper()

def count_vowels(s):
    vowels = 'aeiouAEIOU'
    return sum(1 for char in s if char in vowels)

# main.py
from string_functions import reverse_string, uppercase_string, count_vowels

user_input = input("Enter a string: ")

reversed_str = reverse_string(user_input)
print(f"Reversed String: {reversed_str}")

uppercase_str = uppercase_string(user_input)
print(f"Uppercase String: {uppercase_str}")

vowel_count = count_vowels(user_input)
print(f"Vowel Count: {vowel_count}")

import os

directory_path = 'example_directory'
subdirectory_path = os.path.join(directory_path, 'example_subdirectory')

os.makedirs(subdirectory_path)

print(f"Current Working Directory: {os.getcwd()}")
print(f"List of Files in Directory: {os.listdir(directory_path)}")

# cal.py

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    if b != 0:
        return a / b
    else:
        return "Cannot divide by zero"

# main.py
from cal import add, subtract, multiply, divide

num1 = float(input("Enter first number: "))
num2 = float(input("Enter second number: "))

result_add = add(num1, num2)
print(f"Addition: {result_add}")

result_subtract = subtract(num1, num2)
print(f"Subtraction: {result_subtract}")

result_multiply = multiply(num1, num2)
print(f"Multiplication: {result_multiply}")

result_divide = divide(num1, num2)
print(f"Division: {result_divide}")

# first_word.py

def get_first_word(s):
    return s.split()[0]

# main.py
from first_word import get_first_word

input_string = 'This is Python Programming'
result = get_first_word(input_string)
print(f"Output: {result}")

# main.py

input_filename = 'File1.txt'
output_filename = 'File2.txt'

with open(input_filename, 'r') as input_file, open(output_filename, 'w') as output_file:
    for line in input_file:
        if '#' not in line:
            output_file.write(line)

class NumberSet:
    def __init__(self, num1, num2):
        self.num1 = num1
        self.num2 = num2

# Create an instance
t = NumberSet(6, 10)

class Animal:
    def __init__(self, arms, legs):
        self.arms = arms
        self.legs = legs

    def limbs(self):
        return self.arms + self.legs

# Create an instance
spider = Animal(4, 4)

# Call the limbs method
spidlimbs = spider.limbs()

class Vehicle:
    def __init__(self, max_speed, mileage):
        self.max_speed = max_speed
        self.mileage = mileage

class Student:
    def __init__(self, student_name, marks):
        self.student_name = student_name
        self.marks = marks

# Create an instance
student_instance = Student("John", 85)

# Print original values
print(f"Original values: {student_instance.student_name}, {student_instance.marks}")

# Modify attribute values
student_instance.student_name = "Jane"
student_instance.marks = 90

# Print modified values
print(f"Modified values: {student_instance.student_name}, {student_instance.marks}")

class Student:
    def __init__(self, student_id, student_name):
        self.student_id = student_id
        self.student_name = student_name
        self.student_class = None

    def display_attributes(self):
        print(f"ID: {self.student_id}, Name: {self.student_name}, Class: {self.student_class}")

# Create an instance
student_instance = Student(1, "John")

# Set the student_class attribute
student_instance.student_class = "Grade 10"

# Display attributes
student_instance.display_attributes()

class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width

    def area(self):
        return self.length * self.width

# Create an instance
rectangle_instance = Rectangle(5, 8)

# Compute the area
area = rectangle_instance.area()
print(f"Area of the rectangle: {area}")

import math

class Circle:
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return math.pi * (self.radius ** 2)

    def perimeter(self):
        return 2 * math.pi * self.radius

# Create an instance
circle_instance = Circle(4)

# Compute area and perimeter
area = circle_instance.area()
perimeter = circle_instance.perimeter()

print(f"Area of the circle: {area}")
print(f"Perimeter of the circle: {perimeter}")

try:
    num = int(input("Enter a number: "))
    result = 10 / num
except ZeroDivisionError:
    print("Cannot divide by zero!")
except ValueError:
    print("Invalid input! Please enter a number.")
else:
    print(f"The result is: {result}")

def check_positive_number(num):
    if num <= 0:
        raise ValueError("Number must be positive")

try:
    user_input = int(input("Enter a positive number: "))
    check_positive_number(user_input)
    print("Valid input!")
except ValueError as e:
    print(f"Error: {e}")

class CustomException(Exception):
    pass

def check_even_number(num):
    if num % 2 != 0:
        raise CustomException("Number must be even")

try:
    user_input = int(input("Enter an even number: "))
    check_even_number(user_input)
    print("Valid input!")
except CustomException as ce:
    print(f"Error: {ce}")

class Student:
    def __init__(self):
        self.students = []

    def accept(self):
        name = input("Enter student name: ")
        roll_no = int(input("Enter roll number: "))
        marks1 = int(input("Enter marks for subject 1: "))
        marks2 = int(input("Enter marks for subject 2: "))
        student_data = {"Name": name, "RollNo": roll_no, "Marks1": marks1, "Marks2": marks2}
        self.students.append(student_data)
        print("Student details accepted successfully!")

    def display(self):
        print("\nList of Students:")
        for student in self.students:
            print(f"Name   : {student['Name']}")
            print(f"RollNo : {student['RollNo']}")
            print(f"Marks1 : {student['Marks1']}")
            print(f"Marks2 : {student['Marks2']}\n")

    def search(self, roll_no):
        for student in self.students:
            if student['RollNo'] == roll_no:
                print("Student found:")
                print(f"Name   : {student['Name']}")
                print(f"RollNo : {student['RollNo']}")
                print(f"Marks1 : {student['Marks1']}")
                print(f"Marks2 : {student['Marks2']}")
                return
        print("Student not found.")

    def delete(self, roll_no):
        for student in self.students:
            if student['RollNo'] == roll_no:
                self.students.remove(student)
                print("Student deleted successfully.")
                return
        print("Student not found.")

    def update(self, old_roll_no, new_roll_no):
        for student in self.students:
            if student['RollNo'] == old_roll_no:
                student['RollNo'] = new_roll_no
                print("Student roll number updated successfully.")
                return
        print("Student not found.")

# Example usage:
student_system = Student()

# Accepting students
student_system.accept()
student_system.accept()

# Displaying students
student_system.display()

# Searching for a student
student_system.search(1)

# Deleting a student
student_system.delete(1)

# Updating a student's roll number
student_system.update(2, 3)

# Displaying updated list
student_system.display()

class InvalidToppingException(Exception):
    pass

class InvalidCheeseException(Exception):
    pass

class Pizza:
    def __init__(self, size, toppings, cheese):
        self.size = size
        self.toppings = toppings
        self.cheese = cheese
        self.validate_toppings()
        self.validate_cheese()

    def validate_toppings(self):
        valid_toppings = ['corn', 'tomato', 'onion', 'capsicum', 'mushroom', 'olives', 'broccoli']
        for topping in self.toppings:
            if topping not in valid_toppings:
                raise InvalidToppingException(f"Invalid topping: {topping}")

    def validate_cheese(self):
        valid_cheese = ['mozzarella', 'feta', 'cheddar']
        for cheese in self.cheese:
            if cheese not in valid_cheese:
                raise InvalidCheeseException(f"Invalid cheese: {cheese}")

    def price(self):
        size_price = {'small': 50, 'medium': 100, 'large': 200}
        topping_price = 20
        exotic_toppings_price = 50
        cheese_price = 50

        total_price = size_price[self.size]

        for topping in self.toppings:
            if topping in ['broccoli', 'olives', 'mushroom']:
                total_price += exotic_toppings_price
            else:
                total_price += topping_price

        total_price += len(self.cheese) * cheese_price
        return total_price


class Order:
    def __init__(self, name, customer_id):
        self.name = name
        self.customer_id = customer_id
        self.pizzas = []

    def order(self, pizza):
        self.pizzas.append(pizza)

    def bill(self):
        total_cost = 0
        print(f"Order details for customer {self.name} (ID: {self.customer_id}):")
        for index, pizza in enumerate(self.pizzas, start=1):
            print(f"\nPizza {index}:")
            print(f"Size: {pizza.size}")
            print(f"Toppings: {', '.join(pizza.toppings)}")
            print(f"Cheese: {', '.join(pizza.cheese)}")
            pizza_cost = pizza.price()
            print(f"Cost: {pizza_cost} rupees")
            total_cost += pizza_cost
        print(f"\nTotal Order Cost: {total_cost} rupees")


# Example usage:
try:
    pizza1 = Pizza('medium', ['corn', 'tomato'], ['mozzarella', 'feta'])
    pizza2 = Pizza('large', ['mushroom', 'olives'], ['cheddar'])
    pizza3 = Pizza('small', ['onion', 'capsicum', 'broccoli'], ['mozzarella'])

    order = Order("John Doe", 123)
    order.order(pizza1)
    order.order(pizza2)
    order.order(pizza3)

    order.bill()
except InvalidToppingException as ite:
    print(f"Error: {ite}")
except InvalidCheeseException as ice:
    print(f"Error: {ice}")

class WordPlay:
    def __init__(self, word_list):
        self.words = word_list

    def words_with_length(self, length):
        return [word for word in self.words if len(word) == length]

    def starts_with(self, char1):
        return [word for word in self.words if word[:len(char1)] == char1]

    def ends_with(self, char2):
        return [word for word in self.words if word[-len(char2):] == char2]

    def palindromes(self):
        return [word for word in self.words if word == word[::-1]]

    def only(self, str1):
        return [word for word in self.words if self.all_chars_in_word(str1, word)]

    def avoids(self, str2):
        return [word for word in self.words if not self.any_char_in_word(str2, word)]

    @staticmethod
    def all_chars_in_word(chars, word):
        for char in chars:
            char_found = False
            for w_char in word:
                if w_char == char:
                    char_found = True
                    break
            if not char_found:
                return False
        return True

    @staticmethod
    def any_char_in_word(chars, word):
        for char in chars:
            for w_char in word:
                if w_char == char:
                    return True
        return False

# Example usage:
word_list = ['apple', 'banana', 'find', 'dictionary', 'set', 'tuple', 'list', 'malayalam', 'nayan', 'grind', 'apricot']

word_play = WordPlay(word_list)

print("Words with length 5:", word_play.words_with_length(5))
print("Words starting with 'a':", word_play.starts_with('a'))
print("Words ending with 'd':", word_play.ends_with('d'))
print("Palindromes:", word_play.palindromes())
print("Words containing only 'bna':", word_play.only('bna'))
print("Words avoiding 'amkd':", word_play.avoids('amkd'))

class Store:
    def __init__(self):
        self.products = {}

    def add_product(self, code, price):
        self.products[code] = price

    def display_menu(self):
        print("Item Code\t Price")
        for code, price in self.products.items():
            print(f"{code}\t\t {price}")

    def generate_bill(self, quantities):
        print("\n************************Bill**********************")
        print("ITEM\t PRICE\t QUANTITY\t\t SUBTOTAL")
        
        total_amount = 0
        for code, quantity in quantities.items():
            if code in self.products:
                price = self.products[code]
                subtotal = price * quantity
                total_amount += subtotal
                print(f"{code}\t {price}\t {quantity}\t\t\t {subtotal}")

        print("**************************************************")
        print(f"Total=  {total_amount}")

# Example usage:
store = Store()

# Adding products to the store
store.add_product("milk", 30)
store.add_product("apple", 35)
store.add_product("gems", 40)

# Displaying the menu
store.display_menu()

# Taking input for quantities
num_items = int(input("Enter no of items: "))
quantities = {}
for _ in range(num_items):
    code = input("Enter code of item: ")
    quantity = int(input(f"Enter quantity of {code} : "))
    quantities[code] = quantity

# Generating and displaying the bill
store.generate_bill(quantities)

import math

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return math.sqrt(self.x**2 + self.y**2)

    def translate(self, dx, dy):
        return Point(self.x + dx, self.y + dy)

    def reflect_x(self):
        return Point(self.x, -self.y)

    def distance(self, other_point):
        return math.sqrt((self.x - other_point.x)**2 + (self.y - other_point.y)**2)

# Test Case
point = Point(1, 2)

# Distance from origin
print(f"Distance from origin: {point.distance_from_origin():.2f}")

# Translate method
translated_point = point.translate(1, 1)
print(f"Translate method: Point ({point.x},{point.y}) translated by (1,1) is at ({translated_point.x},{translated_point.y}) now")

# Reflect_x method
reflected_point = point.reflect_x()
print(f"Reflect_x method: Point ({point.x},{point.y}) after given reflection is at ({reflected_point.x},{reflected_point.y})")

# Distance method
other_point = Point(3, 4)
print(f"Distance method: Distance between Point ({point.x},{point.y}) and ({other_point.x},{other_point.y}) is {point.distance(other_point):.2f}")

class Song:
    def __init__(self, title, duration):
        self.title = title
        self.duration = duration
        self.album = None  # Associated album

class Artist:
    def __init__(self, name):
        self.name = name
        self.albums = []  # List of albums by the artist
        self.songs = []   # List of individual songs by the artist

    def add_album(self, album):
        self.albums.append(album)

    def add_song(self, song):
        self.songs.append(song)

class Album:
    def __init__(self, title, artist):
        self.title = title
        self.artist = artist
        self.tracks = []  # List of tracks in the album

    def add_track(self, song):
        self.tracks.append(song)
        song.album = self  # Set the associated album for the song

class Playlist:
    def __init__(self, title):
        self.title = title
        self.songs = []  # List of songs in the playlist

    def add_song(self, song):
        self.songs.append(song)

# Example usage:
# Create artists
artist1 = Artist("Artist1")
artist2 = Artist("Various Artists")

# Create songs
song1 = Song("Song1", 180)
song2 = Song("Song2", 200)

# Create albums
album1 = Album("Album1", artist1)
album1.add_track(song1)
album1.add_track(song2)

album2 = Album("Compilation Album", artist2)
album2.add_track(song1)

# Add albums to artists
artist1.add_album(album1)
artist2.add_album(album2)

# Create a playlist
playlist = Playlist("My Playlist")

# Add songs to the playlist
playlist.add_song(song1)
playlist.add_song(song2)

# Display information
print("Playlist:", playlist.title)
print("Songs in the playlist:")
for song in playlist.songs:
    print(f"- {song.title} ({song.duration} seconds)")

# Display artists and their albums
print("\nArtists and their albums:")
for artist in [artist1, artist2]:
    print(f"{artist.name}:")
    for album in artist.albums:
        print(f"- {album.title}")

# Display albums and their tracks
print("\nAlbums and their tracks:")
for album in [album1, album2]:
    print(f"{album.title} by {album.artist.name}:")
    for track in album.tracks:
        print(f"- {track.title} ({track.duration} seconds)")

class EmptyListError(Exception):
    pass

class SQ:
    def __init__(self, initial_list=None):
        self.items = initial_list or []

    def shift(self):
        if not self.items:
            raise EmptyListError("Cannot shift from an empty list")
        return self.items.pop(0)

    def unshift(self, item):
        self.items.insert(0, item)

    def push(self, item):
        self.items.append(item)

    def pop(self):
        if not self.items:
            raise EmptyListError("Cannot pop from an empty list")
        return self.items.pop()

    def remove(self):
        if not self.items:
            raise EmptyListError("Cannot remove from an empty list")
        max_element = max(self.items)
        self.items.remove(max_element)
        return max_element

    def __str__(self):
        return str(self.items).replace("[0, ", "[")

# Example usage:
sq = SQ([1, 2, 3, 4, 5])

# Shift
try:
    print("Shifted:", sq.shift())
except EmptyListError as e:
    print(e)

# Unshift
sq.unshift(0)
print("After Unshift:", sq)

# Push
sq.push(6)
print("After Push:", sq)

# Pop
try:
    print("Popped:", sq.pop())
except EmptyListError as e:
    print(e)

# Remove
try:
    print("Removed Max Element:", sq.remove())
except EmptyListError as e:
    print(e)

# Display final state
print("Final State:", sq)